// $ANTLR 2.7.4: "langparser.g" -> "AspectLanguageParser.cs"$

// Generate the header common to all output files.
using System;
using System.Text;
using AspectSharp.Lang.AST;
using BitSet = antlr.collections.impl.BitSet;
using NoViableAltException = antlr.NoViableAltException;
using ParserSharedInputState = antlr.ParserSharedInputState;
using RecognitionException = antlr.RecognitionException;
using Token = antlr.Token;
using TokenBuffer = antlr.TokenBuffer;
using TokenStream = antlr.TokenStream;
using TokenType = AspectSharp.Lang.TokenType;

public class AspectLanguageParser : antlr.LLkParser
{
    protected StringBuilder sbuilder = new StringBuilder();

    protected LexicalInfo ToLexicalInfo(antlr.Token token)
    {
        int line = token.getLine();
        int startColumn = token.getColumn();
        int endColumn = token.getColumn() + token.getText().Length;
        String filename = token.getFilename();
        return new LexicalInfo { Filename = filename, Line = line, StartColumn = startColumn, EndColumn = endColumn };
    }

    protected String methodAll(String s)
    {
        if (s == "*")
            return ".*";
        return s;
    }

    protected void initialize()
    {
        tokenNames = tokenNames_;
    }


    protected AspectLanguageParser(TokenBuffer tokenBuf, int k)
        : base(tokenBuf, k)
    {
        initialize();
    }

    public AspectLanguageParser(TokenBuffer tokenBuf)
        : this(tokenBuf, 1)
    {
    }

    protected AspectLanguageParser(TokenStream lexer, int k)
        : base(lexer, k)
    {
        initialize();
    }

    public AspectLanguageParser(TokenStream lexer)
        : this(lexer, 1)
    {
    }

    public AspectLanguageParser(ParserSharedInputState state)
        : base(state, 1)
    {
        initialize();
    }
   
    public EngineConfiguration start() 
    {

        EngineConfiguration conf= new EngineConfiguration();

        try
        {      
            for (; ; )
            {
                if ((LA(1) != TokenType.EOS))
                    break;
                match(TokenType.EOS);
            }

            for (; ; )
            {
                if ((LA(1) != TokenType.IMPORT))
                    break;
                import_directive(conf);
            }


            for (; ; )
            {
                if ((LA(1) != TokenType.INTERCEPTORS))
                    break;
                interceptors_global(conf);
            }


            for (; ; )
            {
                if ((LA(1) != TokenType.MIXINS))
                    break;
                mixins_global(conf);
            }



            for (; ; )
            {
                if ((LA(1) != TokenType.ASPECT))
                    break;
                aspects(conf);
            }

            match(Token.EOF_TYPE);
        }
        catch (RecognitionException ex)
        {
            reportError(ex);
            consume();
            consumeUntil(tokenSet_0_);
        }
        return conf;
    }

    protected void import_directive( EngineConfiguration conf ) 
    {

        Token i = null;

        String ns;
        String assemblyName;
        ImportDirective import = null;


        try
        {      // for error handling
            i = LT(1);
            match(TokenType.IMPORT);
            ns = identifier();

            import = new ImportDirective(ToLexicalInfo(i), ns);
            conf.Imports.Add(import);

                switch (LA(1))
                {
                    case TokenType.IN:
                        match(TokenType.IN);
                            assemblyName = identifier();
                            import.AssemblyReference = new AssemblyReference(ToLexicalInfo(i), assemblyName);
                            break;
                    case TokenType.EOF:
                    case TokenType.ASPECT:
                    case TokenType.IMPORT:
                    case TokenType.MIXINS:
                    case TokenType.INTERCEPTORS:
                            break;
                    default:
                            throw new NoViableAltException(LT(1), getFilename());
                }
        }
        catch (RecognitionException ex)
        {
            reportError(ex);
            consume();
            consumeUntil(tokenSet_1_);
        }
    }

    protected void interceptors_global( EngineConfiguration conf) 
    {
        try
        {      // for error handling
            match(TokenType.INTERCEPTORS);
            keytypepair(conf.Interceptors);
        }
        catch (RecognitionException ex)
        {
            reportError(ex);
            consume();
            consumeUntil(tokenSet_2_);
        }
    }

    protected void mixins_global(EngineConfiguration conf )
    {
        try
        {      // for error handling
            match(TokenType.MIXINS);
            keytypepair(conf.Mixins);
        }
        catch (RecognitionException ex)
        {
            reportError(ex);
            consume();
            consumeUntil(tokenSet_3_);
        }
    }

    protected void aspects(EngineConfiguration conf ) 
    {

        Token token = null;
        Token aspectId = null;

        AspectDefinition aspect = null;
        TargetTypeDefinition target = null;
        TypeReference tr = null;


        try
        {      // for error handling
            token = LT(1);
            match(TokenType.ASPECT);
            aspectId = LT(1);
            match(TokenType.ID);
            match(TokenType.FOR);

            aspect = new AspectDefinition(ToLexicalInfo(token), aspectId.getText());
            conf.Aspects.Add(aspect);

            switch (LA(1))
            {
                case TokenType.ID:
                    tr = type_name_def();

                    target = new TargetTypeDefinition(tr);
                    target.TargetStrategy = TargetStrategyEnum.SingleType;
                    aspect.TargetType = target;

                    break;
                case TokenType.LBRACK:
                    match(TokenType.LBRACK);

                    target = new TargetTypeDefinition();
                    aspect.TargetType = target;
                    String namespaceRegEx = null;

                    switch (LA(1))
                    {
                        case TokenType.ASSIGNFROM:
                            match(TokenType.ASSIGNFROM);
                            match(TokenType.LCURLY);
                            tr = type_name_def();
                            match(TokenType.RCURLY);
                            target.TargetStrategy = TargetStrategyEnum.Assignable;
                            target.AssignType = tr;
                            break;
                        case TokenType.CUSTOMMATCHER:
                            match(TokenType.CUSTOMMATCHER);
                            match(TokenType.LCURLY);
                            tr = type_name_def();
                            match(TokenType.RCURLY);
                            target.TargetStrategy = TargetStrategyEnum.Custom;
                            target.CustomMatcherType = tr;
                            break;
                        case TokenType.ID:
                            namespaceRegEx = identifier();
                            target.TargetStrategy = TargetStrategyEnum.Namespace;
                            target.NamespaceRoot = namespaceRegEx;
                            switch (LA(1))
                            {
                                case TokenType.EXCLUDES:
                                    match(TokenType.EXCLUDES);
                                    match(TokenType.LCURLY);
                                    type_list(target.Excludes);
                                    match(TokenType.RCURLY);
                                    break;
                                case TokenType.RBRACK:
                                    break;
                                default:
                                    throw new NoViableAltException(LT(1), getFilename());
                            }
                            break;
                        default:
                            throw new NoViableAltException(LT(1), getFilename());
                    }
                    match(TokenType.RBRACK);
                    break;
                default:
                    throw new NoViableAltException(LT(1), getFilename());
            }


            for (; ; )
            {
                if ((LA(1) != TokenType.INCLUDE))
                    break;
                include(aspect);
            }

            for (; ; )
            {
                if ((LA(1) != TokenType.POINTCUT))
                    break;
                pointcut(aspect);
            }

            match(TokenType.END);
        }
        catch (RecognitionException ex)
        {
            reportError(ex);
            consume();
            consumeUntil(tokenSet_4_);
        }
    }

    protected String identifier() //throws RecognitionException, TokenStreamException
    {
        String value;
        Token id = null;
        Token id2 = null;
        value = null; 
        sbuilder.Length = 0;


        try
        {      // for error handling
            id = LT(1);
            match(TokenType.ID);

            sbuilder.Append(id.getText());
            value = sbuilder.ToString();

            for (; ; )
            {
                if ((LA(1) != TokenType.DOT))
                    break;
                match(TokenType.DOT);
                id2 = LT(1);
                match(TokenType.ID);
                sbuilder.Append('.');
                sbuilder.Append(id2.getText());
            }
            value = sbuilder.ToString();
        }
        catch (RecognitionException ex)
        {
            reportError(ex);
            consume();
            consumeUntil(tokenSet_5_);
        }
        return value;
    }

    protected void keytypepair(IDeclarationCollection collection ) 
    {
        try
        {      // for error handling
            match(TokenType.LBRACK);
            {
                pairvalue(collection);
                {    // ( ... )*
                    for (; ; )
                    {
                        if ((LA(1) == TokenType.SEMI))
                        {
                            match(TokenType.SEMI);
                            pairvalue(collection);
                        }
                        else
                            goto _loop20_breakloop;
                    }
                _loop20_breakloop: ;
                }    // ( ... )*
            }
            match(TokenType.RBRACK);
        }
        catch (RecognitionException ex)
        {
            reportError(ex);
            consume();
            consumeUntil(tokenSet_2_);
        }
    }

    protected void pairvalue(IDeclarationCollection collection) 
    {

        Token keyToken = null;
        DefinitionBase definition = null;


        try
        {      // for error handling
            keyToken = LT(1);
            match(TokenType.STRING_LITERAL);
            match(TokenType.COLON);

            String key = keyToken.getText();
            definition = collection.Add(key, ToLexicalInfo(keyToken));

            type_name(definition);
        }
        catch (RecognitionException ex)
        {
            reportError(ex);
            consume();
            consumeUntil(tokenSet_6_);
        }
    }

    protected void type_name(DefinitionBase definition)
    {


        TypeReference tr = null;


        try
        {      // for error handling
            tr = type_name_def();

            definition.TypeReference = tr;

        }
        catch (RecognitionException ex)
        {
            reportError(ex);
            consume();
            consumeUntil(tokenSet_6_);
        }
    }

    protected TypeReference type_name_or_ref() //throws RecognitionException, TokenStreamException
    {
        TypeReference type;

        Token refTypeToken = null;

        type = null;


        try
        {      // for error handling
            switch (LA(1))
            {
                case TokenType.STRING_LITERAL:
                    {
                        refTypeToken = LT(1);
                        match(TokenType.STRING_LITERAL);

                        type = new TypeReference();
                        type.Type = refTypeToken.getText();
                        type.TargetType = TargetTypeEnum.Link;
                        // type.LinkRef = refTypeToken.getText();

                        break;
                    }
                case TokenType.ID:
                    {
                        type = type_name_def();
                        break;
                    }
                default:
                    {
                        throw new NoViableAltException(LT(1), getFilename());
                    }
            }
        }
        catch (RecognitionException ex)
        {
            reportError(ex);
            consume();
            consumeUntil(tokenSet_7_);
        }
        return type;
    }

    protected TypeReference type_name_def() //throws RecognitionException, TokenStreamException
    {
        TypeReference type = new TypeReference();
        Token i = null;
        String typeToken = null;
        String assemblyToken = null;


        try
        {      // for error handling
            typeToken = identifier();
            type.Type = typeToken;
            type.TargetType = TargetTypeEnum.Type;
            // type.TypeName = typeToken;

            switch (LA(1))
            {
                case TokenType.IN:
                    i = LT(1);
                    match(TokenType.IN);
                    assemblyToken = identifier();
                    type.AssemblyReference = new AssemblyReference(ToLexicalInfo(i), assemblyToken);
                    break;
                case TokenType.END:
                case TokenType.INCLUDE:
                case TokenType.POINTCUT:
                case TokenType.SEMI:
                case TokenType.RBRACK:
                case TokenType.RCURLY:
                        break;
                default:
                        throw new NoViableAltException(LT(1), getFilename());
            }
        }
        catch (RecognitionException ex)
        {
            reportError(ex);
            consume();
            consumeUntil(tokenSet_8_);
        }
        return type;
    }

    protected void type_list(TypeReferenceCollection types ) 
    {
        TypeReference tr = null;

        try
        {      // for error handling
            tr = type_name_def();
            types.Add(tr);

            for (; ; )
            {
                if ((LA(1) != TokenType.SEMI))
                    break;
                match(TokenType.SEMI);
                tr = type_name_def();
                types.Add(tr);
            }

        }
        catch (RecognitionException ex)
        {
            reportError(ex);
            consume();
            consumeUntil(tokenSet_9_);
        }
    }

    protected void include(AspectDefinition aspect ) 
    {

        Token i = null;
        TypeReference tr = null;
        MixinDefinition md;

        try
        {    
            i = LT(1);
            match(TokenType.INCLUDE);

            md = new MixinDefinition(ToLexicalInfo(i));
            tr = type_name_or_ref();

            md.TypeReference = tr;
            aspect.Mixins.Add(md);

        }
        catch (RecognitionException ex)
        {
            reportError(ex);
            consume();
            consumeUntil(tokenSet_10_);
        }
    }

    protected void pointcut( AspectDefinition aspect  ) //throws RecognitionException, TokenStreamException
    {

        Token p = null;

        PointCutDefinition pointcut = null;
        PointCutFlags flags = PointCutFlags.Unspecified;


        try
        {      // for error handling
            p = LT(1);
            match(TokenType.POINTCUT);
            flags = pointcutflags();

            pointcut = new PointCutDefinition(ToLexicalInfo(p), flags);
            aspect.PointCuts.Add(pointcut);

            pointcuttarget(pointcut);
            advices(pointcut);
            match(TokenType.END);
        }
        catch (RecognitionException ex)
        {
            reportError(ex);
            consume();
            consumeUntil(tokenSet_11_);
        }
    }

    protected PointCutFlags pointcutflags() //throws RecognitionException, TokenStreamException
    {
        PointCutFlags flags;


        flags = PointCutFlags.Unspecified;


        try
        {      // for error handling
            flags = pointcutflag(flags);
        
                switch (LA(1))
                {
                    case TokenType.OR:
                        match(TokenType.OR);
                            flags = pointcutflag(flags);
                            break;
                    case TokenType.LCURLY:
                            break;
                    default:
                            throw new NoViableAltException(LT(1), getFilename());
                }
        
        }
        catch (RecognitionException ex)
        {
            reportError(ex);
            consume();
            consumeUntil(tokenSet_12_);
        }
        return flags;
    }

    protected void pointcuttarget(PointCutDefinition pointcut) //throws RecognitionException, TokenStreamException
    {


        try
        {      // for error handling
            match(TokenType.LCURLY);
            pointcutsignature(pointcut);
        }
        catch (RecognitionException ex)
        {
            reportError(ex);
            consume();
            consumeUntil(tokenSet_13_);
        }
    }

    protected void advices( PointCutDefinition pointcut) //throws RecognitionException, TokenStreamException
    {
        try
        {    
            for (; ; )
            {
                if ((LA(1) != TokenType.ADVICEINTERCEPTOR))
                    break;
                advice(pointcut);
            }
        }
        catch (RecognitionException ex)
        {
            reportError(ex);
            consume();
            consumeUntil(tokenSet_14_);
        }
    }

    protected void advice(PointCutDefinition pointcut) //throws RecognitionException, TokenStreamException
    {

        Token i = null;

        TypeReference tr = null;
        InterceptorDefinition interDef = null;


        try
        {      // for error handling
            i = LT(1);
            match(TokenType.ADVICEINTERCEPTOR);

            interDef = new InterceptorDefinition(ToLexicalInfo(i));

            match(TokenType.LCURLY);
            tr = type_name_or_ref();

            interDef.TypeReference = tr;
            pointcut.Advices.Add(interDef);

            match(TokenType.RCURLY);
        }
        catch (RecognitionException ex)
        {
            reportError(ex);
            consume();
            consumeUntil(tokenSet_13_);
        }
    }

    protected PointCutFlags pointcutflag(PointCutFlags flags) //throws RecognitionException, TokenStreamException
    {

        PointCutFlags retValue = flags;

        try
        {      // for error handling
            switch (LA(1))
            {
                case TokenType.METHOD:
                    match(TokenType.METHOD);
                        retValue |= PointCutFlags.Method;
                        break;
                case TokenType.PROPERTY:
                        match(TokenType.PROPERTY);
                        retValue |= PointCutFlags.Property;
                        break;
                case TokenType.PROPERTY_READ:
                        match(TokenType.PROPERTY_READ);
                        retValue |= PointCutFlags.PropertyRead;
                        break;
                case TokenType.PROPERTY_WRITE:
                        match(TokenType.PROPERTY_WRITE);
                        retValue |= PointCutFlags.PropertyWrite;
                        break;
                default:
                        throw new NoViableAltException(LT(1), getFilename());
            }
        }
        catch (RecognitionException ex)
        {
            reportError(ex);
            consume();
            consumeUntil(tokenSet_15_);
        }
        return retValue;
    }

    protected void pointcutsignature(PointCutDefinition pointcut ) //throws RecognitionException, TokenStreamException
    {


        try
        {      // for error handling
            pointcutsig1(pointcut);
        }
        catch (RecognitionException ex)
        {
            reportError(ex);
            consume();
            consumeUntil(tokenSet_13_);
        }
    }

    protected void pointcutsig1( PointCutDefinition pointcut ) //throws RecognitionException, TokenStreamException
    {

        String part1;
        MethodSignature ms = null;

        try
        {      // for error handling
            switch (LA(1))
            {
                case TokenType.ALL:
                    match(TokenType.ALL);
                        part1 = "*";
                        ms = AllMethodSignature.Instance;
                        break;
                case TokenType.ID:
                        part1 = reg_ex(true);
                        ms = new MethodSignature(part1, methodAll("*"));
                        break;
                default:
                        throw new NoViableAltException(LT(1), getFilename());
            }
            pointcut.Method = pointcutsig2(part1, ms);
        }
        catch (RecognitionException ex)
        {
            reportError(ex);
            consume();
            consumeUntil(tokenSet_13_);
        }
    }

    protected String reg_ex(Boolean allowALL ) //throws RecognitionException, TokenStreamException
    {
        String value;
        Token id = null;
        value = null; 
        sbuilder.Length = 0;

        try
        {      // for error handling
            id = LT(1);
            match(TokenType.ID);

            sbuilder.Append(id.getText());
            value = sbuilder.ToString();

            switch (LA(1))
            {
                case TokenType.WS:
                    match(TokenType.WS);
                        break;
                case TokenType.DOT:
                        match(TokenType.DOT);
                        sbuilder.Append('.');
                        match(TokenType.ALL);
                        sbuilder.Append('*');
                        break;
                default:
                        if ((tokenSet_16_.member(LA(1))))
                        {
                            if (LA(1) == TokenType.ALL)
                            {
                                if (allowALL)
                                    break;
                                throw new NoViableAltException(LT(1), getFilename());
                            }
                        }
                        else if ((tokenSet_16_.member(LA(1)))) { }
                        else
                            throw new NoViableAltException(LT(1), getFilename());
                    break;
            }

            value = sbuilder.ToString();

        }
        catch (RecognitionException ex)
        {
            reportError(ex);
            consume();
            consumeUntil(tokenSet_16_);
        }
        return value;
    }

    protected MethodSignature pointcutsig2(String part1, MethodSignature ms ) //throws RecognitionException, TokenStreamException
    {
        MethodSignature ret;
        String part2;
        ret = null;


        try
        {      // for error handling
            switch (LA(1))
            {
                case TokenType.ALL:
                    match(TokenType.ALL);
                    part2 = "*";
                    ret = pointcutsig3(part1, part2, ms);
                    break;
                case TokenType.LCURLY:
                    match(TokenType.LCURLY);
                    pointcutarguments(ms);
                    match(TokenType.RCURLY);
                    match(TokenType.RCURLY);
                    ret = ms;
                    break;
                case TokenType.RCURLY:
                    match(TokenType.RCURLY);
                    ret = ms;
                    break;
                case TokenType.ID:
                    part2 = reg_ex(true);
                    ret = pointcutsig3(part1, part2, ms);
                    break;
                default:
                    throw new NoViableAltException(LT(1), getFilename());
            }
        }
        catch (RecognitionException ex)
        {
            reportError(ex);
            consume();
            consumeUntil(tokenSet_0_);
        }
        return ret;
    }

    protected MethodSignature pointcutsig3( String part1, String part2, MethodSignature ms ) //throws RecognitionException, TokenStreamException
    {
        MethodSignature ret =null;
        String part3;

        try
        {      // for error handling
            switch (LA(1))
            {
                case TokenType.ALL:
                    match(TokenType.ALL);
                        part3 = "*";
                        ms = new MethodSignature(part1, part2, methodAll(part3));
                        pointcutsig4(ms);
                        break;
                case TokenType.LCURLY:
                        match(TokenType.LCURLY);
                        ms = new MethodSignature(part1, methodAll(part2));
                        pointcutarguments(ms);
                        match(TokenType.RCURLY);
                        match(TokenType.RCURLY);
                        break;
                case TokenType.RCURLY:
                        match(TokenType.RCURLY);
                        ms = new MethodSignature(part1, methodAll(part2));
                        break;
                case TokenType.ID:
                        part3 = reg_ex(false);
                        ms = new MethodSignature(part1, part2, methodAll(part3));
                        pointcutsig4(ms);
                        break;
                default:
                        throw new NoViableAltException(LT(1), getFilename());
            }
            ret = ms;
        }
        catch (RecognitionException ex)
        {
            reportError(ex);
            consume();
            consumeUntil(tokenSet_0_);
        }
        return ret;
    }

    protected void pointcutarguments( MethodSignature ms ) 
    {


        try
        {      // for error handling
            switch (LA(1))
            {
                case TokenType.ID:
                case TokenType.ALL:
                        pointcutargument(ms);
                        for (; ; )
                        {
                            if ((LA(1) != TokenType.COMMA))
                                break;
                            match(TokenType.COMMA);
                            pointcutargument(ms);
                        }
                        break;
                case TokenType.RCURLY:
                        break;
                default:
                        throw new NoViableAltException(LT(1), getFilename());
            }
        }
        catch (RecognitionException ex)
        {
            reportError(ex);
            consume();
            consumeUntil(tokenSet_9_);
        }
    }

    protected void pointcutsig4( MethodSignature ms) //throws RecognitionException, TokenStreamException
    {
        try
        {      // for error handling
            switch (LA(1))
            {
                case TokenType.LCURLY:
                    match(TokenType.LCURLY);
                    pointcutarguments(ms);
                    match(TokenType.RCURLY);
                    match(TokenType.RCURLY);
                    break;
                case TokenType.RCURLY:
                    match(TokenType.RCURLY);
                    break;
                default:
                    throw new NoViableAltException(LT(1), getFilename());
            }
        }
        catch (RecognitionException ex)
        {
            reportError(ex);
            consume();
            consumeUntil(tokenSet_0_);
        }
    }

    protected void pointcutargument(MethodSignature ms) //throws RecognitionException, TokenStreamException
    {


        String argType = String.Empty;

        try
        {      // for error handling
            switch (LA(1))
            {
                case TokenType.ALL:
                    match(TokenType.ALL);
                        ms.AddArgumentType("*");
                        break;
                case TokenType.ID:
                        argType = reg_ex(false);
                        ms.AddArgumentType(argType);
                        break;
                default:
                        throw new NoViableAltException(LT(1), getFilename());
            }
        }
        catch (RecognitionException ex)
        {
            reportError(ex);
            consume();
            consumeUntil(tokenSet_17_);
        }
    }

    private void initializeFactory()
    {
    }

    public static readonly string[] tokenNames_ = new string[] {
		@"""<0>""",
		@"""EOF""",
		@"""<2>""",
		@"""NULL_TREE_LOOKAHEAD""",
		@"""aspect""",
		@"""for""",
		@"""in""",
		@"""end""",
		@"""import""",
		@"""mixins""",
		@"""include""",
		@"""interceptors""",
		@"""advice""",
		@"""pointcut""",
		@"""method""",
		@"""property""",
		@"""propertyread""",
		@"""propertywrite""",
		@"""assignableFrom""",
		@"""customMatcher""",
		@"""excludes""",
		@"""includes""",
		@"""EOS""",
		@"""LBRACK""",
		@"""SEMI""",
		@"""RBRACK""",
		@"""STRING_LITERAL""",
		@"""COLON""",
		@"""ID""",
		@"""LCURLY""",
		@"""RCURLY""",
		@"""OR""",
		@"""ALL""",
		@"""COMMA""",
		@"""DOT""",
		@"""WS"""
	};

    private static long[] mk_tokenSet_0_()
    {
        long[] data = { 2L, 0L };
        return data;
    }
    public static readonly BitSet tokenSet_0_ = new BitSet(mk_tokenSet_0_());
    private static long[] mk_tokenSet_1_()
    {
        long[] data = { 2834L, 0L };
        return data;
    }
    public static readonly BitSet tokenSet_1_ = new BitSet(mk_tokenSet_1_());
    private static long[] mk_tokenSet_2_()
    {
        long[] data = { 2578L, 0L };
        return data;
    }
    public static readonly BitSet tokenSet_2_ = new BitSet(mk_tokenSet_2_());
    private static long[] mk_tokenSet_3_()
    {
        long[] data = { 530L, 0L };
        return data;
    }
    public static readonly BitSet tokenSet_3_ = new BitSet(mk_tokenSet_3_());
    private static long[] mk_tokenSet_4_()
    {
        long[] data = { 18L, 0L };
        return data;
    }
    public static readonly BitSet tokenSet_4_ = new BitSet(mk_tokenSet_4_());
    private static long[] mk_tokenSet_5_()
    {
        long[] data = { 1125134290L, 0L };
        return data;
    }
    public static readonly BitSet tokenSet_5_ = new BitSet(mk_tokenSet_5_());
    private static long[] mk_tokenSet_6_()
    {
        long[] data = { 50331648L, 0L };
        return data;
    }
    public static readonly BitSet tokenSet_6_ = new BitSet(mk_tokenSet_6_());
    private static long[] mk_tokenSet_7_()
    {
        long[] data = { 1073751168L, 0L };
        return data;
    }
    public static readonly BitSet tokenSet_7_ = new BitSet(mk_tokenSet_7_());
    private static long[] mk_tokenSet_8_()
    {
        long[] data = { 1124082816L, 0L };
        return data;
    }
    public static readonly BitSet tokenSet_8_ = new BitSet(mk_tokenSet_8_());
    private static long[] mk_tokenSet_9_()
    {
        long[] data = { 1073741824L, 0L };
        return data;
    }
    public static readonly BitSet tokenSet_9_ = new BitSet(mk_tokenSet_9_());
    private static long[] mk_tokenSet_10_()
    {
        long[] data = { 9344L, 0L };
        return data;
    }
    public static readonly BitSet tokenSet_10_ = new BitSet(mk_tokenSet_10_());
    private static long[] mk_tokenSet_11_()
    {
        long[] data = { 8320L, 0L };
        return data;
    }
    public static readonly BitSet tokenSet_11_ = new BitSet(mk_tokenSet_11_());
    private static long[] mk_tokenSet_12_()
    {
        long[] data = { 536870912L, 0L };
        return data;
    }
    public static readonly BitSet tokenSet_12_ = new BitSet(mk_tokenSet_12_());
    private static long[] mk_tokenSet_13_()
    {
        long[] data = { 4224L, 0L };
        return data;
    }
    public static readonly BitSet tokenSet_13_ = new BitSet(mk_tokenSet_13_());
    private static long[] mk_tokenSet_14_()
    {
        long[] data = { 128L, 0L };
        return data;
    }
    public static readonly BitSet tokenSet_14_ = new BitSet(mk_tokenSet_14_());
    private static long[] mk_tokenSet_15_()
    {
        long[] data = { 2684354560L, 0L };
        return data;
    }
    public static readonly BitSet tokenSet_15_ = new BitSet(mk_tokenSet_15_());
    private static long[] mk_tokenSet_16_()
    {
        long[] data = { 14763954304L, 0L };
        return data;
    }
    public static readonly BitSet tokenSet_16_ = new BitSet(mk_tokenSet_16_());
    private static long[] mk_tokenSet_17_()
    {
        long[] data = { 9663676416L, 0L };
        return data;
    }
    public static readonly BitSet tokenSet_17_ = new BitSet(mk_tokenSet_17_());

}
